Ordinal-System Array
The Ordinal-System Array is an extension to the FGH, or better said a function that directly defines ordinals for the FGH. It was created by MachineGun. Notation We use OSA(x)n where "x" is a number in the array which will be transformed into an ordinal, and "n" is the FGH input Rules: ''' *0's are ignored, except in the 1 argument array OSA(x)n = \(f_{\omega^{x}}(n)\), except if "x" is 0. Then it will turn into \(f_{\omega}(n)\). It seems like if x is 1, it will have the same value. Now, for multiple entry arrays we have the following rule: -1's are transformed into \(\omega\)'s (or the corresponding ordinal defined before solving the array, you will see what I mean a bit later) -A number k>1 will be transformed with the following rule: solving from left to right, we decompose "k" into however many "k-1"'s as entries to the right there are, and we keep decomposing until we reach the last 2 entries which will be decomposed them from right to left, using the same rule. If we have 3 entries, then for the middle entry "m" we decompose it into 2 "m-1"'s (2 total entries on the sides) Example: \(OSA(3,3,3,3)n = OSA(2,2,2,2,2,2,2,2,2,2)n\) -> we now decompose into even more 1's. When reaching the final state of the array, we start to nest the ordinals. (for omega exponentiation, and for the other ordinals index nesting, surely you know what I mean.) Example: \(OSA(1,1,1,1)n = \omega^{\omega^{\omega^{\omega}}}\), because we have 4 1's. '''Mixed array: When not all the numbers are the same, decompose using the same rule, and keep on doing it until you have decomposed everything into 1's. Then and only then you can start calculating the ordinal. Example: \(OSA(3,4,5)n = OSA(2,2,3,3,4,4)n\) -> I have decomposed this and trust me there were A LOTTA 1's. Attributing different ordinals than \(\omega\) OSA0(#)n has 1 = \(\omega\). The strenght of OSA0(1,1,1,....,1,1,1)n with a 1s is \(\omega\)↑↑a Strength of OSA_0(2,2,2,...,2,2,2)n with a 1s might be w^^round(0.75*a^2)? OSA1(#)n has 1 = \(\varepsilon_n\) OSAm(#)n has 1 = \(\varphi(m,n)\) So for example: OSA0(1,1,1)3 = \(f_{\omega^{\omega^{\omega}}}(3)\) OSA1(1,1,1)3 = \(f_{\varepsilon_{\varepsilon_{\varepsilon_{3}}}}(3)\). * When creating ordinals with OSA and you have multiple entries, there will be no "n" to apply to the ordinals when having 1's. To solve that, we can just have "0" indexed. etc. If in OSA0 just a single number meant omega exponentiation, in OSA bigger than 0 a single entry array means indexing x to the corresponding ordinal. Eg: OSA0(x)n has a growth rate of \(f_{\omega^{x}}(n)\) OSA1(x)n has a growth rate of \(f({\varepsilon_{x}},n)\) If not, then the other rules apply. *Instead of numbers, you can also just index the ordinal itself, for example OSA0(n) = OSA\(\omega\)(n) Define the rule OSA(x,a)n = OSA(x,x,x,....,x,x,x)n with a x's. Another notational change This can also be used as a pure ordinal creating function, that is if we don't include the FGH input. Multiple row array Define OSA(m)(m)n as OSAOSAOSA...OSAm(m)n(m)n(m)n, with "m" OSA's OSA(m)(x)n = "m" iterations of OSA, with the last one being indexed with "x" Rules for more than 2 rows OSA(m)(m)(m)n = OSA(OSA(m)(m)n)(OSA(m)(m)n)[OSA(m)(m)n] OSA(a)(b)©(d)(...(x)(y)n with "l" rows = OSA(OSA(a)(b)©(.....(x)n)(OSA(a)(b)©(.....(x)n(...(OSA(a)(b)©(.....(x)n)[OSA(y)(y)(...(y)n, "l-1" rows] with "l-1" rows Examples: OSA(m)(x)(m)n = OSA(OSA(m)(x)n)(OSA(m)(x)n)[OSA(m)(m)n] OSA(a)(b)©n = OSA(OSA(a)(b)n)(OSA(a)(b))[OSA©©n] OSA(a)(b)©(d)(e)n = OSA(OSA(a)(b)©(d)n)(OSA)(a)(b)©(d)n)[OSA(e)(e)(e)(e)n] Hyper Rows OSA((m))n = OSA(m)(m)(m)(m)(....(m)(m)n, with "m" rows OSA((a))((b))(©)((d))(...((x))((y))n with "m" rows = OSA((a))((b))((d))((...((x))[OSA((y))((y))((y))((y))((...((y))n], with m-1 rows] with m-1 rows OSA{m}n = OSA((m))((m))((m))((...((m))n with m rows Same iteration rules as the (()) Then we can have stuff like OSA{2m}n, and this would break into an iteration of the {}'s (with the same rules as before) Then OSA{3m}n, iteration of OSA{2m}n We can define OSA&mn = OSA{OSA{mm}nm}n OSA&&mn = OSA&OSA&m[OSA&m[...OSA&mn]..]]] with m iterations. OSA&&&mn -> iteration of OSA&& the same way OSA/mn = OSA&&&...&&&mn with m &'s. OSA+ and Matrix OSA OSA+ is an updated OSA which can produce even larger numbers. OSA+(1)n = OSA/nn OSA+(1,1)n = OSA+(1)[OSA+(1)[...[OSA+(1)n]..]]], iterated n times For OSA+(1,1,1)n just change the amount of 1's in the bracket to 2, and for "a+1" 1's decompose with "a" 1's in the bracket. For higher numbers like 2,3,4,... we break them down just like how we did in normal OSA. 'Matrix OSA (OSA++) ' Matrix OSA (Or OSA++) is yet another updated OSA. Rules: * For a 1-row matrix of 1's, a single "1" will be transformed into OSA+(n,n,n,...,n,n)n with n n's. So \(OSA++\begin{pmatrix} 1\end{pmatrix}n\) = OSA+(n,n,n,...,n,n)n with n n's (can also be written as OSA+(n,n)n). * For multiple 1's, follow the next rules: \(OSA++\begin{pmatrix} 1 & 1\end{pmatrix}n\) = \(OSA++\begin{pmatrix} 1\end{pmatrix}1\end{pmatrix}[OSA++\begin{pmatrix} 1\end{pmatrix}[...OSA++\begin{pmatrix} 1\end{pmatrix}[n]]..]]\), with n iterations. \(OSA++\begin{pmatrix} 1 & 1 & 1\end{pmatrix}n\) = \(OSA++\begin{pmatrix} 1 & 1\end{pmatrix}1 & 1\end{pmatrix}[OSA++\begin{pmatrix} 1 & 1\end{pmatrix}[...OSA++\begin{pmatrix} 1 & 1\end{pmatrix}[n]]..]]\), with n iterations. Basically for a 1-row matrix with "a" 1's, it will be an iteration of a 1-row matrix with "a-1" 1's. Now for 2's. \(OSA++\begin{pmatrix} 2\end{pmatrix}n\) = \(OSA++\begin{pmatrix} 1 & 1 & 1 & 1 & \cdots & 1\end{pmatrix}n\) with n 1's. Now for multiple 2's the iterations are the same as with multiple 1's. And this means that the general rule is: An "a" will be broken into n "a-1's" As for multiple rows, let's start simple: \(OSA++\begin{pmatrix} 1\\ 1\\\end{pmatrix}n\) = \(OSA++\begin{pmatrix} n & n & n & n & . . . & n\end{pmatrix}n\), with n n's. \(OSA++\begin{pmatrix} 1 & 1\\ 1 & 1\\\end{pmatrix}n\) = \(OSA++\begin{pmatrix} 1\\ 1\\\end{pmatrix}1\\ 1\\\end{pmatrix}[OSA++\begin{pmatrix} 1\\ 1\\\end{pmatrix}[...OSA++\begin{pmatrix} 1\\ 1\\\end{pmatrix}[n..]]]\), with n iterations. And for 2 rows "a" 1's will be an iteration of "a-1" 1's, you know what I mean. \(OSA++\begin{pmatrix} 2\\ 2\\\end{pmatrix}n\) = \(OSA++\begin{pmatrix} 1 & 1 & 1 & ...\\ 1 & 1 & 1 & ...\\\end{pmatrix}n\) with n 1's on both rows (Oh, and also, a rule states that we must have the same number of elements on all rows.) And the same story for multiple 2's, the same iteration that the multiple 1's did. And this means that an "a" will be broken into n "a-1's". \(OSA++\begin{pmatrix} 1\\ 1\\ 1 \end{pmatrix}n\) = \(OSA++\begin{pmatrix} n & n & n & ...\\ n & n & n & ...\\\end{pmatrix}n\), with n n's on both rows.. And the rules are just like the 2-row matrix, reread the rules and you'll understand what I mean. And this just happens to be the case for multiple rows too. Yes, a complicated notation but if you understand how it works you'll also understand its power. There's a final notation: OSA+++n = \(OSA++\begin{pmatrix} n & n & n & ... & n \\ n & n & n & ... & n \\ \vdots & \vdots& \vdots& \vdots& \vdots \\ n & n & n & ... & n \end{pmatrix}n\) with n rows and n elements on each one. We also use OSA+++m,n,p to denote a matrix with "p" rows, with the element "m" "n" times on each one. Old Notation Extension Define \(\alpha + 1\) as some ordinal The # denotes anything OSA\(\alpha+1\)(#)n = OSA\(\alpha\)(#)[OSA\(\alpha\)(#)[....[OSA\(\alpha\)(#)n]..]], with n iterations. For example OSA\(\Gamma_0+1\)(1,1,1)3 = OSA\(\Gamma_0\)(1,1,1)[OSA\(\Gamma_0\)(1,1,1)[OSA\(\Gamma_0\)(1,1,1)3]] AKA a successor iterates the previous one Category:ARRAY NOTATIONS Category:ORDINAL NOTATIONS Category:MachineGun's Functions Category:FGH Numbers Category:Hard Function Category:POTENTIALLY WELL-DEFINED